Abstraktsed klassid vs liidesed: põhjalik juhend disainimustrite rakendamiseks

Objektorienteeritud programmeerimise (OOP) maailmas on abstraktsed klassid ja liidesed põhilised tööriistad abstraktsiooni, polümorfismi ja koodi taaskasutatavuse saavutamiseks. Need on paindlike ja hooldatavate tarkvarasüsteemide loomisel üliolulised. See juhend pakub põhjalikku võrdlust abstraktsete klasside ja liideste vahel, uurides nende sarnasusi, erinevusi ja parimaid tavasid nende tõhusaks kasutamiseks disainimustrite rakendamisel.

Abstraktsiooni ja disainimustrite mõistmine

Enne abstraktsete klasside ja liideste spetsiifikasse süvenemist on oluline mõista abstraktsiooni ja disainimustrite aluseks olevaid kontseptsioone.

Abstraktsioon

Abstraktsioon on keeruliste süsteemide lihtsustamise protsess, modelleerides klasse nende oluliste omaduste põhjal, varjates samal ajal mittevajalikke implementatsiooni detaile. See võimaldab programmeerijatel keskenduda sellele, mida objekt teeb, mitte sellele, kuidas ta seda teeb. See vähendab keerukust ja parandab koodi hooldatavust.

Näiteks vaatleme `Vehicle` (Sõiduk) klassi. Me võiksime abstraheerida ära detailid nagu mootori tüüp või käigukasti spetsiifika ja keskenduda ühistele käitumisviisidele nagu `start()` (käivita), `stop()` (peata) ja `accelerate()` (kiirenda). Konkreetsed klassid nagu `Car` (Auto), `Truck` (Veoauto) ja `Motorcycle` (Mootorratas) päriksid seejärel `Vehicle` klassist ja implementeeriksid need käitumisviisid omal moel.

Disainimustrid

Disainimustrid on korduvkasutatavad lahendused tarkvara disainis sagedasti esinevatele probleemidele. Need esindavad parimaid tavasid, mis on aja jooksul osutunud tõhusaks. Disainimustrite kasutamine võib viia robustsema, hooldatavama ja arusaadavama koodini.

Levinud disainimustrite näited on järgmised:

• Üksik (Singleton): Tagab, et klassil on ainult üks eksemplar ja pakub sellele globaalse juurdepääsupunkti.
• Vabrik (Factory): Pakub liidest objektide loomiseks, kuid delegeerib isendiloome alamklassidele.
• Strateegia (Strategy): Määratleb algoritmide perekonna, kapseldab igaühe neist ja muudab need omavahel vahetatavaks.
• Vaatleja (Observer): Määratleb ühe-mitmele sõltuvuse objektide vahel, nii et kui ühe objekti olek muutub, teavitatakse ja uuendatakse automaatselt kõiki sellest sõltuvaid objekte.

Abstraktsed klassid ja liidesed mängivad paljude disainimustrite rakendamisel otsustavat rolli, võimaldades paindlikke ja laiendatavaid lahendusi.

Abstraktsed klassid: ühise käitumise defineerimine

Abstraktne klass on klass, mida ei saa otse instantseerida. See toimib teiste klasside jaoks mallina, määratledes ühise liidese ja pakkudes potentsiaalselt osalist implementatsiooni. Abstraktsed klassid võivad sisaldada nii abstraktseid meetodeid (meetodid ilma implementatsioonita) kui ka konkreetseid meetodeid (meetodid implementatsiooniga).

Abstraktsete klasside põhiomadused:

• Ei saa otse instantseerida.
• Võivad sisaldada nii abstraktseid kui ka konkreetseid meetodeid.
• Abstraktsed meetodid peavad olema alamklasside poolt implementeeritud.
• Klass saab pärida ainult ühest abstraktsest klassist (ühekordne pärilus).

Näide (Java):

            
// Kujundit esindav abstraktne klass
abstract class Shape {
  // Abstraktne meetod pindala arvutamiseks
  public abstract double calculateArea();

  // Konkreetne meetod kujundi värvi kuvamiseks
  public void displayColor(String color) {
    System.out.println("The shape's color is: " + color);
  }
}

// Ringi esindav konkreetne klass, mis pärib Shape'ist
class Circle extends Shape {
  private double radius;

  public Circle(double radius) {
    this.radius = radius;
  }

  @Override
  public double calculateArea() {
    return Math.PI * radius * radius;
  }
}

            

              
                Copy
              
            
          

Selles näites on `Shape` abstraktne klass abstraktse meetodiga `calculateArea()` ja konkreetse meetodiga `displayColor()`. Klass `Circle` pärib klassist `Shape` ja pakub implementatsiooni meetodile `calculateArea()`. Te ei saa luua otse `Shape` eksemplari; peate looma konkreetse alamklassi, näiteks `Circle`, eksemplari.

Millal kasutada abstraktseid klasse:

• Kui soovite defineerida ühise malli seotud klasside grupile.
• Kui soovite pakkuda vaikimisi implementatsiooni, mida alamklassid saavad pärida.
• Kui peate alamklassidele peale suruma teatud struktuuri või käitumise.

Liidesed: lepingu defineerimine

Liides on täielikult abstraktne tüüp, mis defineerib lepingu, mida klassid peavad implementeerima. See määratleb meetodite kogumi, mille implementeerivad klassid peavad pakkuma. Erinevalt abstraktsetest klassidest ei saa liidesed sisaldada implementatsiooni detaile (välja arvatud vaikemeetodid mõnedes keeltes nagu Java 8 ja hilisemad).

Liideste põhiomadused:

• Ei saa otse instantseerida.
• Võivad sisaldada ainult abstraktseid meetodeid (või vaikemeetodeid mõnedes keeltes).
• Kõik meetodid on kaudselt avalikud (public) ja abstraktsed.
• Klass saab implementeerida mitut liidest (mitmekordne pärilus).

Näide (Java):

            
// Prinditavat objekti defineeriv liides
interface Printable {
  void print();
}

// Klass, mis implementeerib Printable liidest
class Document implements Printable {
  private String content;

  public Document(String content) {
    this.content = content;
  }

  @Override
  public void print() {
    System.out.println("Printing document: " + content);
  }
}

// Teine klass, mis implementeerib Printable liidest
class Image implements Printable {
  private String filename;

  public Image(String filename) {
    this.filename = filename;
  }

  @Override
  public void print() {
    System.out.println("Printing image: " + filename);
  }
}

            

              
                Copy
              
            
          

Selles näites on `Printable` liides ühe meetodiga `print()`. Nii `Document` kui ka `Image` klassid implementeerivad `Printable` liidest, pakkudes oma spetsiifilised implementatsioonid `print()` meetodile. See võimaldab teil käsitleda nii `Document` kui ka `Image` objekte kui `Printable` objekte, võimaldades polümorfismi.

Millal kasutada liideseid:

• Kui soovite defineerida lepingu, mida mitmed omavahel mitteseotud klassid saavad implementeerida.
• Kui soovite saavutada mitmekordset pärilust (simuleerides seda keeltes, mis seda otse ei toeta).
• Kui soovite komponente lahti siduda ja edendada lõdva sidususega (loose coupling) arhitektuuri.

Abstraktsed klassid vs. liidesed: detailne võrdlus

Kuigi nii abstraktsed klassid kui ka liidesed on mõeldud abstraktsiooniks, on neil olulisi erinevusi, mis muudavad nad sobivaks erinevates stsenaariumides.

Disainimustrite rakendamise näited

Uurime, kuidas abstraktseid klasse ja liideseid saab kasutada levinud disainimustrite rakendamiseks.

1. Mallimeetodi muster (Template Method)

Mallimeetodi muster defineerib algoritmi skeleti abstraktses klassis, kuid laseb alamklassidel määratleda algoritmi teatud samme, muutmata algoritmi struktuuri. Abstraktsed klassid sobivad selle mustri jaoks ideaalselt.

Näide (Python):

            
from abc import ABC, abstractmethod

class DataProcessor(ABC):
    def process_data(self):
        self.read_data()
        self.validate_data()
        self.transform_data()
        self.save_data()

    @abstractmethod
    def read_data(self):
        pass

    @abstractmethod
    def validate_data(self):
        pass

    @abstractmethod
    def transform_data(self):
        pass

    @abstractmethod
    def save_data(self):
        pass

class CSVDataProcessor(DataProcessor):
    def read_data(self):
        print("Andmete lugemine CSV-failist...")

    def validate_data(self):
        print("CSV-andmete valideerimine...")

    def transform_data(self):
        print("CSV-andmete teisendamine...")

    def save_data(self):
        print("CSV-andmete salvestamine andmebaasi...")

processor = CSVDataProcessor()
processor.process_data()

            

              
                Copy
              
            
          

Selles näites on `DataProcessor` abstraktne klass, mis defineerib `process_data()` meetodi, mis esindab malli. Alamklassid nagu `CSVDataProcessor` implementeerivad abstraktsed meetodid `read_data()`, `validate_data()`, `transform_data()` ja `save_data()`, et määratleda konkreetsed sammud CSV-andmete töötlemiseks.

2. Strateegiamuster (Strategy)

Strateegiamuster defineerib algoritmide perekonna, kapseldab igaühe neist ja muudab need omavahel vahetatavaks. See laseb algoritmil varieeruda sõltumatult klientidest, kes seda kasutavad. Liidesed sobivad selle mustri jaoks hästi.

Näide (C++):

            
#include <iostream>

// Erinevate makseviiside strateegiate liides
class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
    virtual ~PaymentStrategy() {}
};

// Konkreetne makseviisi strateegia: Krediitkaart
class CreditCardPayment : public PaymentStrategy {
private:
    std::string cardNumber;
    std::string expiryDate;
    std::string cvv;

public:
    CreditCardPayment(std::string cardNumber, std::string expiryDate, std::string cvv) :
        cardNumber(cardNumber), expiryDate(expiryDate), cvv(cvv) {}

    void pay(int amount) override {
        std::cout << "Makstakse " << amount << " krediitkaardiga: " << cardNumber << std::endl;
    }
};

// Konkreetne makseviisi strateegia: PayPal
class PayPalPayment : public PaymentStrategy {
private:
    std::string email;

public:
    PayPalPayment(std::string email) : email(email) {}

    void pay(int amount) override {
        std::cout << "Makstakse " << amount << " PayPaliga: " << email << std::endl;
    }
};

// Kontekstiklass, mis kasutab makseviisi strateegiat
class ShoppingCart {
private:
    PaymentStrategy* paymentStrategy;

public:
    void setPaymentStrategy(PaymentStrategy* paymentStrategy) {
        this->paymentStrategy = paymentStrategy;
    }

    void checkout(int amount) {
        paymentStrategy->pay(amount);
    }
};

int main() {
    ShoppingCart cart;
    CreditCardPayment creditCard("1234-5678-9012-3456", "12/25", "123");
    PayPalPayment paypal("user@example.com");

    cart.setPaymentStrategy(&creditCard);
    cart.checkout(100);

    cart.setPaymentStrategy(&paypal);
    cart.checkout(50);

    return 0;
}

            

              
                Copy
              
            
          

Selles näites on `PaymentStrategy` liides, mis defineerib `pay()` meetodi. Konkreetsed strateegiad nagu `CreditCardPayment` ja `PayPalPayment` implementeerivad `PaymentStrategy` liidest. Klass `ShoppingCart` kasutab maksete sooritamiseks `PaymentStrategy` objekti, mis võimaldab tal hõlpsalt erinevate makseviiside vahel vahetada.

3. Vabrikumeetodi muster (Factory Method)

Vabrikumeetodi muster defineerib liidese objekti loomiseks, kuid laseb alamklassidel otsustada, millist klassi instantseerida. Vabrikumeetod laseb klassil delegeerida instantseerimise alamklassidele. Kasutada võib nii abstraktseid klasse kui ka liideseid, kuid sageli sobivad abstraktseid klassid paremini, kui on vaja teha ühiseid seadistusi.

Näide (TypeScript):

            
// Abstraktne toode
interface Button {
  render(): string;
  onClick(callback: () => void): void;
}

// Konkreetsed tooted
class WindowsButton implements Button {
  render(): string {
    return "<button>Windowsi nupp</button>";
  }
  onClick(callback: () => void): void {
    // Windowsi-spetsiifiline kliki käsitleja
  }
}

class HTMLButton implements Button {
  render(): string {
    return "<button>HTML-i nupp</button>";
  }
  onClick(callback: () => void): void {
    // HTML-i-spetsiifiline kliki käsitleja
  }
}

// Abstraktne looja
abstract class Dialog {
  abstract createButton(): Button;

  render(): string {
    const okButton = this.createButton();
    return `<div>${okButton.render()}</div>`;
  }
}

// Konkreetsed loojad
class WindowsDialog extends Dialog {
  createButton(): Button {
    return new WindowsButton();
  }
}

class WebDialog extends Dialog {
  createButton(): Button {
    return new HTMLButton();
  }
}

// Kasutus
const windowsDialog = new WindowsDialog();
console.log(windowsDialog.render());

const webDialog = new WebDialog();
console.log(webDialog.render());

            

              
                Copy
              
            
          

Selles TypeScripti näites on `Button` abstraktne toode (liides). `WindowsButton` ja `HTMLButton` on konkreetsed tooted. `Dialog` on abstraktne looja (abstraktne klass), mis defineerib `createButton` vabrikumeetodi. `WindowsDialog` ja `WebDialog` on konkreetsed loojad, mis määravad, millist tüüpi nupp luua. See võimaldab teil luua erinevat tüüpi nuppe kliendikoodi muutmata.

Parimad tavad abstraktsete klasside ja liideste kasutamiseks

Abstraktsete klasside ja liideste tõhusaks kasutamiseks kaaluge järgmisi parimaid tavasid:

• Eelistage kompositsiooni pärilusele: Kuigi pärilus võib olla kasulik, võib selle liigne kasutamine viia tihedalt seotud ja paindumatu koodini. Kaaluge paljudel juhtudel päriluse alternatiivina kompositsiooni (kus objektid sisaldavad teisi objekte) kasutamist.
• Järgige liideste eraldamise põhimõtet (Interface Segregation Principle): Kliente ei tohiks sundida sõltuma meetoditest, mida nad ei kasuta. Kujundage liidesed, mis on spetsiifilised klientide vajadustele.
• Kasutage abstraktseid klasse ühise malli defineerimiseks ja osalise implementatsiooni pakkumiseks.
• Kasutage liideseid lepingu defineerimiseks, mida mitmed omavahel mitteseotud klassid saavad implementeerida.
• Vältige sügavaid pärilushierarhiaid: Sügavaid hierarhiaid võib olla raske mõista ja hooldada. Püüdlege madalate, hästi defineeritud hierarhiate poole.
• Dokumenteerige oma abstraktsed klassid ja liidesed: Selgitage selgelt iga abstraktse klassi ja liidese eesmärki ning kasutust, et parandada koodi hooldatavust.

Globaalsed kaalutlused

Globaalsele sihtrühmale tarkvara kujundamisel on ülioluline arvestada selliste teguritega nagu lokaliseerimine, rahvusvahelistamine ja kultuurilised erinevused. Abstraktsed klassid ja liidesed võivad nendes kaalutlustes rolli mängida:

• Lokaliseerimine: Liideseid saab kasutada keelespetsiifiliste käitumisviiside defineerimiseks. Näiteks võiks teil olla `ILanguageFormatter` liides erinevate implementatsioonidega erinevate keelte jaoks, mis tegelevad numbrite vormindamise, kuupäevade vormindamise ja teksti suunaga.
• Rahvusvahelistamine: Abstraktseid klasse saab kasutada ühise baasi defineerimiseks lokaaditeadlikele komponentidele. Näiteks võiks teil olla abstraktne `Currency` (Valuuta) klass alamklassidega erinevate valuutade jaoks, millest igaüks tegeleb oma vormindamis- ja konverteerimisreeglitega.
• Kultuurilised erinevused: Olge teadlik, et teatud disainivalikud võivad olla kultuuriliselt tundlikud. Veenduge, et teie tarkvara on kohandatav erinevatele kultuurinormidele ja eelistustele. Näiteks võivad kuupäevavormingud, aadressivormingud ja isegi värviskeemid kultuuriti erineda.

Rahvusvahelistes meeskondades töötades on selge suhtlus ja dokumentatsioon hädavajalikud. Veenduge, et kõik meeskonnaliikmed mõistavad abstraktsete klasside ja liideste eesmärki ning kasutust ja et kood on kirjutatud viisil, mis on kergesti mõistetav ja hooldatav erineva taustaga arendajatele.

Kokkuvõte

Abstraktsed klassid ja liidesed on võimsad tööriistad abstraktsiooni, polümorfismi ja koodi taaskasutatavuse saavutamiseks objektorienteeritud programmeerimises. Nende erinevuste, sarnasuste ja parimate kasutusviiside mõistmine on ülioluline robustsete, hooldatavate ja laiendatavate tarkvarasüsteemide kujundamisel. Hoolikalt kaaludes oma projekti spetsiifilisi nõudeid ja rakendades selles juhendis toodud põhimõtteid, saate tõhusalt kasutada abstraktseid klasse ja liideseid disainimustrite rakendamiseks ning kvaliteetse tarkvara loomiseks globaalsele sihtrühmale. Pidage meeles eelistada kompositsiooni pärilusele, järgida liideste eraldamise põhimõtet ja püüdke alati luua selget ning lühidat koodi.